//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS MediaConnect service.
///
/// Welcome to the Elemental MediaConnect API reference.  MediaConnect is a service that lets you ingest live video content into the cloud and distribute it to destinations all over the world, both inside and outside the Amazon Web Services cloud. This API reference provides descriptions, syntax, and usage examples for each of the actions and data types that are supported by MediaConnect.  Use the following links to get started with the MediaConnect API:    Actions: An alphabetical list of all MediaConnect API operations.    Data types: An alphabetical list of all MediaConnect data types.    Common parameters: Parameters that all operations can use.    Common errors: Client and server errors that all operations can return.
public struct MediaConnect: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the MediaConnect client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "MediaConnect",
            serviceIdentifier: "mediaconnect",
            serviceProtocol: .restjson,
            apiVersion: "2018-11-14",
            endpoint: endpoint,
            errorType: MediaConnectErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    ///  Adds outputs to an existing bridge.
    @Sendable
    @inlinable
    public func addBridgeOutputs(_ input: AddBridgeOutputsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddBridgeOutputsResponse {
        try await self.client.execute(
            operation: "AddBridgeOutputs", 
            path: "/v1/bridges/{BridgeArn}/outputs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds outputs to an existing bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - outputs:  The outputs that you want to add to this bridge.
    ///   - logger: Logger use during operation
    @inlinable
    public func addBridgeOutputs(
        bridgeArn: String,
        outputs: [AddBridgeOutputRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddBridgeOutputsResponse {
        let input = AddBridgeOutputsRequest(
            bridgeArn: bridgeArn, 
            outputs: outputs
        )
        return try await self.addBridgeOutputs(input, logger: logger)
    }

    ///  Adds sources to an existing bridge.
    @Sendable
    @inlinable
    public func addBridgeSources(_ input: AddBridgeSourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddBridgeSourcesResponse {
        try await self.client.execute(
            operation: "AddBridgeSources", 
            path: "/v1/bridges/{BridgeArn}/sources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds sources to an existing bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - sources:  The sources that you want to add to this bridge.
    ///   - logger: Logger use during operation
    @inlinable
    public func addBridgeSources(
        bridgeArn: String,
        sources: [AddBridgeSourceRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddBridgeSourcesResponse {
        let input = AddBridgeSourcesRequest(
            bridgeArn: bridgeArn, 
            sources: sources
        )
        return try await self.addBridgeSources(input, logger: logger)
    }

    ///  Adds media streams to an existing flow. After you add a media stream to a flow, you can associate it with a source and/or an output that uses the ST 2110 JPEG XS or CDI protocol.
    @Sendable
    @inlinable
    public func addFlowMediaStreams(_ input: AddFlowMediaStreamsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddFlowMediaStreamsResponse {
        try await self.client.execute(
            operation: "AddFlowMediaStreams", 
            path: "/v1/flows/{FlowArn}/mediaStreams", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds media streams to an existing flow. After you add a media stream to a flow, you can associate it with a source and/or an output that uses the ST 2110 JPEG XS or CDI protocol.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow.
    ///   - mediaStreams:  The media streams that you want to add to the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func addFlowMediaStreams(
        flowArn: String,
        mediaStreams: [AddMediaStreamRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddFlowMediaStreamsResponse {
        let input = AddFlowMediaStreamsRequest(
            flowArn: flowArn, 
            mediaStreams: mediaStreams
        )
        return try await self.addFlowMediaStreams(input, logger: logger)
    }

    ///  Adds outputs to an existing flow. You can create up to 50 outputs per flow.
    @Sendable
    @inlinable
    public func addFlowOutputs(_ input: AddFlowOutputsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddFlowOutputsResponse {
        try await self.client.execute(
            operation: "AddFlowOutputs", 
            path: "/v1/flows/{FlowArn}/outputs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds outputs to an existing flow. You can create up to 50 outputs per flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to add outputs to.
    ///   - outputs:  A list of outputs that you want to add to the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func addFlowOutputs(
        flowArn: String,
        outputs: [AddOutputRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddFlowOutputsResponse {
        let input = AddFlowOutputsRequest(
            flowArn: flowArn, 
            outputs: outputs
        )
        return try await self.addFlowOutputs(input, logger: logger)
    }

    ///  Adds sources to a flow.
    @Sendable
    @inlinable
    public func addFlowSources(_ input: AddFlowSourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddFlowSourcesResponse {
        try await self.client.execute(
            operation: "AddFlowSources", 
            path: "/v1/flows/{FlowArn}/source", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds sources to a flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to update.
    ///   - sources:  A list of sources that you want to add to the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func addFlowSources(
        flowArn: String,
        sources: [SetSourceRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddFlowSourcesResponse {
        let input = AddFlowSourcesRequest(
            flowArn: flowArn, 
            sources: sources
        )
        return try await self.addFlowSources(input, logger: logger)
    }

    ///  Adds VPC interfaces to a flow.
    @Sendable
    @inlinable
    public func addFlowVpcInterfaces(_ input: AddFlowVpcInterfacesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AddFlowVpcInterfacesResponse {
        try await self.client.execute(
            operation: "AddFlowVpcInterfaces", 
            path: "/v1/flows/{FlowArn}/vpcInterfaces", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds VPC interfaces to a flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to update.
    ///   - vpcInterfaces:  A list of VPC interfaces that you want to add to the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func addFlowVpcInterfaces(
        flowArn: String,
        vpcInterfaces: [VpcInterfaceRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddFlowVpcInterfacesResponse {
        let input = AddFlowVpcInterfacesRequest(
            flowArn: flowArn, 
            vpcInterfaces: vpcInterfaces
        )
        return try await self.addFlowVpcInterfaces(input, logger: logger)
    }

    ///  Creates a new bridge. The request must include one source.
    @Sendable
    @inlinable
    public func createBridge(_ input: CreateBridgeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBridgeResponse {
        try await self.client.execute(
            operation: "CreateBridge", 
            path: "/v1/bridges", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a new bridge. The request must include one source.
    ///
    /// Parameters:
    ///   - egressGatewayBridge: An egress bridge is a cloud-to-ground bridge. The content comes from an existing MediaConnect flow and is delivered to your premises.
    ///   - ingressGatewayBridge: An ingress bridge is a ground-to-cloud bridge. The content originates at your premises and is delivered to the cloud.
    ///   - name:  The name of the bridge. This name can not be modified after the bridge is created.
    ///   - outputs:  The outputs that you want to add to this bridge.
    ///   - placementArn:  The bridge placement Amazon Resource Number (ARN).
    ///   - sourceFailoverConfig:  The settings for source failover.
    ///   - sources:  The sources that you want to add to this bridge.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBridge(
        egressGatewayBridge: AddEgressGatewayBridgeRequest? = nil,
        ingressGatewayBridge: AddIngressGatewayBridgeRequest? = nil,
        name: String? = nil,
        outputs: [AddBridgeOutputRequest]? = nil,
        placementArn: String? = nil,
        sourceFailoverConfig: FailoverConfig? = nil,
        sources: [AddBridgeSourceRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBridgeResponse {
        let input = CreateBridgeRequest(
            egressGatewayBridge: egressGatewayBridge, 
            ingressGatewayBridge: ingressGatewayBridge, 
            name: name, 
            outputs: outputs, 
            placementArn: placementArn, 
            sourceFailoverConfig: sourceFailoverConfig, 
            sources: sources
        )
        return try await self.createBridge(input, logger: logger)
    }

    ///  Creates a new flow. The request must include one source. The request optionally can include outputs (up to 50) and entitlements (up to 50).
    @Sendable
    @inlinable
    public func createFlow(_ input: CreateFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFlowResponse {
        try await self.client.execute(
            operation: "CreateFlow", 
            path: "/v1/flows", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a new flow. The request must include one source. The request optionally can include outputs (up to 50) and entitlements (up to 50).
    ///
    /// Parameters:
    ///   - availabilityZone:  The Availability Zone that you want to create the flow in. These options are limited to the Availability Zones within the current Amazon Web Services Region.
    ///   - entitlements:  The entitlements that you want to grant on a flow.
    ///   - flowSize:  Determines the processing capacity and feature set of the flow. Set this optional parameter to LARGE if you want to enable NDI outputs on the flow.
    ///   - flowTags:  The key-value pairs that can be used to tag and organize the flow.
    ///   - maintenance:  The maintenance settings you want to use for the flow.
    ///   - mediaStreams:  The media streams that you want to add to the flow. You can associate these media streams with sources and outputs on the flow.
    ///   - name:  The name of the flow.
    ///   - ndiConfig:  Specifies the configuration settings for NDI outputs. Required when the flow includes NDI outputs.
    ///   - outputs:  The outputs that you want to add to this flow.
    ///   - source:  The settings for the source that you want to use for the new flow.
    ///   - sourceFailoverConfig:  The settings for source failover.
    ///   - sourceMonitoringConfig:  The settings for source monitoring.
    ///   - sources: The sources that are assigned to the flow.
    ///   - vpcInterfaces:  The VPC interfaces you want on the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFlow(
        availabilityZone: String? = nil,
        entitlements: [GrantEntitlementRequest]? = nil,
        flowSize: FlowSize? = nil,
        flowTags: [String: String]? = nil,
        maintenance: AddMaintenance? = nil,
        mediaStreams: [AddMediaStreamRequest]? = nil,
        name: String? = nil,
        ndiConfig: NdiConfig? = nil,
        outputs: [AddOutputRequest]? = nil,
        source: SetSourceRequest? = nil,
        sourceFailoverConfig: FailoverConfig? = nil,
        sourceMonitoringConfig: MonitoringConfig? = nil,
        sources: [SetSourceRequest]? = nil,
        vpcInterfaces: [VpcInterfaceRequest]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFlowResponse {
        let input = CreateFlowRequest(
            availabilityZone: availabilityZone, 
            entitlements: entitlements, 
            flowSize: flowSize, 
            flowTags: flowTags, 
            maintenance: maintenance, 
            mediaStreams: mediaStreams, 
            name: name, 
            ndiConfig: ndiConfig, 
            outputs: outputs, 
            source: source, 
            sourceFailoverConfig: sourceFailoverConfig, 
            sourceMonitoringConfig: sourceMonitoringConfig, 
            sources: sources, 
            vpcInterfaces: vpcInterfaces
        )
        return try await self.createFlow(input, logger: logger)
    }

    ///  Creates a new gateway. The request must include at least one network (up to four).
    @Sendable
    @inlinable
    public func createGateway(_ input: CreateGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGatewayResponse {
        try await self.client.execute(
            operation: "CreateGateway", 
            path: "/v1/gateways", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a new gateway. The request must include at least one network (up to four).
    ///
    /// Parameters:
    ///   - egressCidrBlocks:  The range of IP addresses that are allowed to contribute content or initiate output requests for flows communicating with this gateway. These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.
    ///   - name:  The name of the gateway. This name can not be modified after the gateway is created.
    ///   - networks:  The list of networks that you want to add to the gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGateway(
        egressCidrBlocks: [String]? = nil,
        name: String? = nil,
        networks: [GatewayNetwork]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGatewayResponse {
        let input = CreateGatewayRequest(
            egressCidrBlocks: egressCidrBlocks, 
            name: name, 
            networks: networks
        )
        return try await self.createGateway(input, logger: logger)
    }

    ///  Deletes a bridge. Before you can delete a bridge, you must stop the bridge.
    @Sendable
    @inlinable
    public func deleteBridge(_ input: DeleteBridgeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBridgeResponse {
        try await self.client.execute(
            operation: "DeleteBridge", 
            path: "/v1/bridges/{BridgeArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a bridge. Before you can delete a bridge, you must stop the bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBridge(
        bridgeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBridgeResponse {
        let input = DeleteBridgeRequest(
            bridgeArn: bridgeArn
        )
        return try await self.deleteBridge(input, logger: logger)
    }

    ///  Deletes a flow. Before you can delete a flow, you must stop the flow.
    @Sendable
    @inlinable
    public func deleteFlow(_ input: DeleteFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFlowResponse {
        try await self.client.execute(
            operation: "DeleteFlow", 
            path: "/v1/flows/{FlowArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a flow. Before you can delete a flow, you must stop the flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFlow(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFlowResponse {
        let input = DeleteFlowRequest(
            flowArn: flowArn
        )
        return try await self.deleteFlow(input, logger: logger)
    }

    ///  Deletes a gateway. Before you can delete a gateway, you must deregister its instances and delete its bridges.
    @Sendable
    @inlinable
    public func deleteGateway(_ input: DeleteGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGatewayResponse {
        try await self.client.execute(
            operation: "DeleteGateway", 
            path: "/v1/gateways/{GatewayArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a gateway. Before you can delete a gateway, you must deregister its instances and delete its bridges.
    ///
    /// Parameters:
    ///   - gatewayArn:  The Amazon Resource Name (ARN) of the gateway that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGateway(
        gatewayArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGatewayResponse {
        let input = DeleteGatewayRequest(
            gatewayArn: gatewayArn
        )
        return try await self.deleteGateway(input, logger: logger)
    }

    ///  Deregisters an instance. Before you deregister an instance, all bridges running on the instance must be stopped. If you want to deregister an instance without stopping the bridges, you must use the --force option.
    @Sendable
    @inlinable
    public func deregisterGatewayInstance(_ input: DeregisterGatewayInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterGatewayInstanceResponse {
        try await self.client.execute(
            operation: "DeregisterGatewayInstance", 
            path: "/v1/gateway-instances/{GatewayInstanceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deregisters an instance. Before you deregister an instance, all bridges running on the instance must be stopped. If you want to deregister an instance without stopping the bridges, you must use the --force option.
    ///
    /// Parameters:
    ///   - force:  Force the deregistration of an instance. Force will deregister an instance, even if there are bridges running on it.
    ///   - gatewayInstanceArn:  The Amazon Resource Name (ARN) of the gateway that contains the instance that you want to deregister.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterGatewayInstance(
        force: Bool? = nil,
        gatewayInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterGatewayInstanceResponse {
        let input = DeregisterGatewayInstanceRequest(
            force: force, 
            gatewayInstanceArn: gatewayInstanceArn
        )
        return try await self.deregisterGatewayInstance(input, logger: logger)
    }

    ///  Displays the details of a bridge.
    @Sendable
    @inlinable
    public func describeBridge(_ input: DescribeBridgeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBridgeResponse {
        try await self.client.execute(
            operation: "DescribeBridge", 
            path: "/v1/bridges/{BridgeArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of a bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBridge(
        bridgeArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBridgeResponse {
        let input = DescribeBridgeRequest(
            bridgeArn: bridgeArn
        )
        return try await self.describeBridge(input, logger: logger)
    }

    ///  Displays the details of a flow. The response includes the flow Amazon Resource Name (ARN), name, and Availability Zone, as well as details about the source, outputs, and entitlements.
    @Sendable
    @inlinable
    public func describeFlow(_ input: DescribeFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFlowResponse {
        try await self.client.execute(
            operation: "DescribeFlow", 
            path: "/v1/flows/{FlowArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of a flow. The response includes the flow Amazon Resource Name (ARN), name, and Availability Zone, as well as details about the source, outputs, and entitlements.
    ///
    /// Parameters:
    ///   - flowArn:  The ARN of the flow that you want to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFlow(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFlowResponse {
        let input = DescribeFlowRequest(
            flowArn: flowArn
        )
        return try await self.describeFlow(input, logger: logger)
    }

    ///  The DescribeFlowSourceMetadata API is used to view information about the flow's source transport stream and programs. This API displays status messages about the flow's source as well as details about the program's video, audio, and other data.
    @Sendable
    @inlinable
    public func describeFlowSourceMetadata(_ input: DescribeFlowSourceMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFlowSourceMetadataResponse {
        try await self.client.execute(
            operation: "DescribeFlowSourceMetadata", 
            path: "/v1/flows/{FlowArn}/source-metadata", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  The DescribeFlowSourceMetadata API is used to view information about the flow's source transport stream and programs. This API displays status messages about the flow's source as well as details about the program's video, audio, and other data.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFlowSourceMetadata(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFlowSourceMetadataResponse {
        let input = DescribeFlowSourceMetadataRequest(
            flowArn: flowArn
        )
        return try await self.describeFlowSourceMetadata(input, logger: logger)
    }

    ///  Describes the thumbnail for the flow source.
    @Sendable
    @inlinable
    public func describeFlowSourceThumbnail(_ input: DescribeFlowSourceThumbnailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFlowSourceThumbnailResponse {
        try await self.client.execute(
            operation: "DescribeFlowSourceThumbnail", 
            path: "/v1/flows/{FlowArn}/source-thumbnail", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes the thumbnail for the flow source.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFlowSourceThumbnail(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFlowSourceThumbnailResponse {
        let input = DescribeFlowSourceThumbnailRequest(
            flowArn: flowArn
        )
        return try await self.describeFlowSourceThumbnail(input, logger: logger)
    }

    ///  Displays the details of a gateway. The response includes the gateway Amazon Resource Name (ARN), name, and CIDR blocks, as well as details about the networks.
    @Sendable
    @inlinable
    public func describeGateway(_ input: DescribeGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeGatewayResponse {
        try await self.client.execute(
            operation: "DescribeGateway", 
            path: "/v1/gateways/{GatewayArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of a gateway. The response includes the gateway Amazon Resource Name (ARN), name, and CIDR blocks, as well as details about the networks.
    ///
    /// Parameters:
    ///   - gatewayArn:  The ARN of the gateway that you want to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeGateway(
        gatewayArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeGatewayResponse {
        let input = DescribeGatewayRequest(
            gatewayArn: gatewayArn
        )
        return try await self.describeGateway(input, logger: logger)
    }

    ///  Displays the details of an instance.
    @Sendable
    @inlinable
    public func describeGatewayInstance(_ input: DescribeGatewayInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeGatewayInstanceResponse {
        try await self.client.execute(
            operation: "DescribeGatewayInstance", 
            path: "/v1/gateway-instances/{GatewayInstanceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of an instance.
    ///
    /// Parameters:
    ///   - gatewayInstanceArn:  The Amazon Resource Name (ARN) of the gateway instance that you want to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeGatewayInstance(
        gatewayInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeGatewayInstanceResponse {
        let input = DescribeGatewayInstanceRequest(
            gatewayInstanceArn: gatewayInstanceArn
        )
        return try await self.describeGatewayInstance(input, logger: logger)
    }

    ///  Displays the details of an offering. The response includes the offering description, duration, outbound bandwidth, price, and Amazon Resource Name (ARN).
    @Sendable
    @inlinable
    public func describeOffering(_ input: DescribeOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeOfferingResponse {
        try await self.client.execute(
            operation: "DescribeOffering", 
            path: "/v1/offerings/{OfferingArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of an offering. The response includes the offering description, duration, outbound bandwidth, price, and Amazon Resource Name (ARN).
    ///
    /// Parameters:
    ///   - offeringArn:  The ARN of the offering.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeOffering(
        offeringArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeOfferingResponse {
        let input = DescribeOfferingRequest(
            offeringArn: offeringArn
        )
        return try await self.describeOffering(input, logger: logger)
    }

    ///  Displays the details of a reservation. The response includes the reservation name, state, start date and time, and the details of the offering that make up the rest of the reservation (such as price, duration, and outbound bandwidth).
    @Sendable
    @inlinable
    public func describeReservation(_ input: DescribeReservationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReservationResponse {
        try await self.client.execute(
            operation: "DescribeReservation", 
            path: "/v1/reservations/{ReservationArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays the details of a reservation. The response includes the reservation name, state, start date and time, and the details of the offering that make up the rest of the reservation (such as price, duration, and outbound bandwidth).
    ///
    /// Parameters:
    ///   - reservationArn: The Amazon Resource Name (ARN) of the offering.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReservation(
        reservationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReservationResponse {
        let input = DescribeReservationRequest(
            reservationArn: reservationArn
        )
        return try await self.describeReservation(input, logger: logger)
    }

    ///  Grants entitlements to an existing flow.
    @Sendable
    @inlinable
    public func grantFlowEntitlements(_ input: GrantFlowEntitlementsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GrantFlowEntitlementsResponse {
        try await self.client.execute(
            operation: "GrantFlowEntitlements", 
            path: "/v1/flows/{FlowArn}/entitlements", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Grants entitlements to an existing flow.
    ///
    /// Parameters:
    ///   - entitlements:  The list of entitlements that you want to grant.
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to grant entitlements on.
    ///   - logger: Logger use during operation
    @inlinable
    public func grantFlowEntitlements(
        entitlements: [GrantEntitlementRequest]? = nil,
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GrantFlowEntitlementsResponse {
        let input = GrantFlowEntitlementsRequest(
            entitlements: entitlements, 
            flowArn: flowArn
        )
        return try await self.grantFlowEntitlements(input, logger: logger)
    }

    ///  Displays a list of bridges that are associated with this account and an optionally specified Amazon Resource Name (ARN). This request returns a paginated result.
    @Sendable
    @inlinable
    public func listBridges(_ input: ListBridgesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBridgesResponse {
        try await self.client.execute(
            operation: "ListBridges", 
            path: "/v1/bridges", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of bridges that are associated with this account and an optionally specified Amazon Resource Name (ARN). This request returns a paginated result.
    ///
    /// Parameters:
    ///   - filterArn:  Filter the list results to display only the bridges associated with the selected ARN.
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListBridges request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListBridges request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListBridges request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBridges(
        filterArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBridgesResponse {
        let input = ListBridgesRequest(
            filterArn: filterArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBridges(input, logger: logger)
    }

    ///  Displays a list of all entitlements that have been granted to this account. This request returns 20 results per page.
    @Sendable
    @inlinable
    public func listEntitlements(_ input: ListEntitlementsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEntitlementsResponse {
        try await self.client.execute(
            operation: "ListEntitlements", 
            path: "/v1/entitlements", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of all entitlements that have been granted to this account. This request returns 20 results per page.
    ///
    /// Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListEntitlements request with set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 20 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListEntitlements request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListEntitlements request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEntitlements(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEntitlementsResponse {
        let input = ListEntitlementsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listEntitlements(input, logger: logger)
    }

    ///  Displays a list of flows that are associated with this account. This request returns a paginated result.
    @Sendable
    @inlinable
    public func listFlows(_ input: ListFlowsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFlowsResponse {
        try await self.client.execute(
            operation: "ListFlows", 
            path: "/v1/flows", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of flows that are associated with this account. This request returns a paginated result.
    ///
    /// Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListFlows request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListFlows request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListFlows request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFlows(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFlowsResponse {
        let input = ListFlowsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFlows(input, logger: logger)
    }

    ///  Displays a list of instances associated with the Amazon Web Services account. This request returns a paginated result. You can use the filterArn property to display only the instances associated with the selected Gateway Amazon Resource Name (ARN).
    @Sendable
    @inlinable
    public func listGatewayInstances(_ input: ListGatewayInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGatewayInstancesResponse {
        try await self.client.execute(
            operation: "ListGatewayInstances", 
            path: "/v1/gateway-instances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of instances associated with the Amazon Web Services account. This request returns a paginated result. You can use the filterArn property to display only the instances associated with the selected Gateway Amazon Resource Name (ARN).
    ///
    /// Parameters:
    ///   - filterArn:  Filter the list results to display only the instances associated with the selected Gateway ARN.
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListInstances request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListInstances request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListInstances request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGatewayInstances(
        filterArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGatewayInstancesResponse {
        let input = ListGatewayInstancesRequest(
            filterArn: filterArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGatewayInstances(input, logger: logger)
    }

    ///  Displays a list of gateways that are associated with this account. This request returns a paginated result.
    @Sendable
    @inlinable
    public func listGateways(_ input: ListGatewaysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListGatewaysResponse {
        try await self.client.execute(
            operation: "ListGateways", 
            path: "/v1/gateways", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of gateways that are associated with this account. This request returns a paginated result.
    ///
    /// Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListGateways request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListGateways request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListGateways request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGateways(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGatewaysResponse {
        let input = ListGatewaysRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGateways(input, logger: logger)
    }

    ///  Displays a list of all offerings that are available to this account in the current Amazon Web Services Region. If you have an active reservation (which means you've purchased an offering that has already started and hasn't expired yet), your account isn't eligible for other offerings.
    @Sendable
    @inlinable
    public func listOfferings(_ input: ListOfferingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOfferingsResponse {
        try await self.client.execute(
            operation: "ListOfferings", 
            path: "/v1/offerings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of all offerings that are available to this account in the current Amazon Web Services Region. If you have an active reservation (which means you've purchased an offering that has already started and hasn't expired yet), your account isn't eligible for other offerings.
    ///
    /// Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListOfferings request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListOfferings request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListOfferings request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOfferings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOfferingsResponse {
        let input = ListOfferingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOfferings(input, logger: logger)
    }

    ///  Displays a list of all reservations that have been purchased by this account in the current Amazon Web Services Region. This list includes all reservations in all states (such as active and expired).
    @Sendable
    @inlinable
    public func listReservations(_ input: ListReservationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReservationsResponse {
        try await self.client.execute(
            operation: "ListReservations", 
            path: "/v1/reservations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Displays a list of all reservations that have been purchased by this account in the current Amazon Web Services Region. This list includes all reservations in all states (such as active and expired).
    ///
    /// Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListReservations request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - nextToken:  The token that identifies the batch of results that you want to see.  For example, you submit a ListReservations request with MaxResults set at 5. The service returns the first batch of results (up to 5) and a NextToken value. To see the next batch of results, you can submit the ListOfferings request a second time and specify the NextToken value.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReservations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReservationsResponse {
        let input = ListReservationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReservations(input, logger: logger)
    }

    ///  List all tags on a MediaConnect resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  List all tags on a MediaConnect resource.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) that identifies the MediaConnect resource for which to list the tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    ///  Submits a request to purchase an offering. If you already have an active reservation, you can't purchase another offering.
    @Sendable
    @inlinable
    public func purchaseOffering(_ input: PurchaseOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PurchaseOfferingResponse {
        try await self.client.execute(
            operation: "PurchaseOffering", 
            path: "/v1/offerings/{OfferingArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Submits a request to purchase an offering. If you already have an active reservation, you can't purchase another offering.
    ///
    /// Parameters:
    ///   - offeringArn:  The Amazon Resource Name (ARN) of the offering.
    ///   - reservationName:  The name that you want to use for the reservation.
    ///   - start:  The date and time that you want the reservation to begin, in Coordinated Universal Time (UTC).  You can specify any date and time between 12:00am on the first day of the current month to the current time on today's date, inclusive. Specify the start in a 24-hour notation. Use the following format: YYYY-MM-DDTHH:mm:SSZ, where T and Z are literal characters. For example, to specify 11:30pm on March 5, 2020, enter 2020-03-05T23:30:00Z.
    ///   - logger: Logger use during operation
    @inlinable
    public func purchaseOffering(
        offeringArn: String,
        reservationName: String? = nil,
        start: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PurchaseOfferingResponse {
        let input = PurchaseOfferingRequest(
            offeringArn: offeringArn, 
            reservationName: reservationName, 
            start: start
        )
        return try await self.purchaseOffering(input, logger: logger)
    }

    ///  Removes an output from a bridge.
    @Sendable
    @inlinable
    public func removeBridgeOutput(_ input: RemoveBridgeOutputRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveBridgeOutputResponse {
        try await self.client.execute(
            operation: "RemoveBridgeOutput", 
            path: "/v1/bridges/{BridgeArn}/outputs/{OutputName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes an output from a bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - outputName:  The name of the bridge output that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeBridgeOutput(
        bridgeArn: String,
        outputName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveBridgeOutputResponse {
        let input = RemoveBridgeOutputRequest(
            bridgeArn: bridgeArn, 
            outputName: outputName
        )
        return try await self.removeBridgeOutput(input, logger: logger)
    }

    ///  Removes a source from a bridge.
    @Sendable
    @inlinable
    public func removeBridgeSource(_ input: RemoveBridgeSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveBridgeSourceResponse {
        try await self.client.execute(
            operation: "RemoveBridgeSource", 
            path: "/v1/bridges/{BridgeArn}/sources/{SourceName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes a source from a bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - sourceName:  The name of the bridge source that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeBridgeSource(
        bridgeArn: String,
        sourceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveBridgeSourceResponse {
        let input = RemoveBridgeSourceRequest(
            bridgeArn: bridgeArn, 
            sourceName: sourceName
        )
        return try await self.removeBridgeSource(input, logger: logger)
    }

    ///  Removes a media stream from a flow. This action is only available if the media stream is not associated with a source or output.
    @Sendable
    @inlinable
    public func removeFlowMediaStream(_ input: RemoveFlowMediaStreamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveFlowMediaStreamResponse {
        try await self.client.execute(
            operation: "RemoveFlowMediaStream", 
            path: "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes a media stream from a flow. This action is only available if the media stream is not associated with a source or output.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to update.
    ///   - mediaStreamName:  The name of the media stream that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeFlowMediaStream(
        flowArn: String,
        mediaStreamName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveFlowMediaStreamResponse {
        let input = RemoveFlowMediaStreamRequest(
            flowArn: flowArn, 
            mediaStreamName: mediaStreamName
        )
        return try await self.removeFlowMediaStream(input, logger: logger)
    }

    ///  Removes an output from an existing flow. This request can be made only on an output that does not have an entitlement associated with it. If the output has an entitlement, you must revoke the entitlement instead. When an entitlement is revoked from a flow, the service automatically removes the associated output.
    @Sendable
    @inlinable
    public func removeFlowOutput(_ input: RemoveFlowOutputRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveFlowOutputResponse {
        try await self.client.execute(
            operation: "RemoveFlowOutput", 
            path: "/v1/flows/{FlowArn}/outputs/{OutputArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes an output from an existing flow. This request can be made only on an output that does not have an entitlement associated with it. If the output has an entitlement, you must revoke the entitlement instead. When an entitlement is revoked from a flow, the service automatically removes the associated output.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to remove an output from.
    ///   - outputArn:  The ARN of the output that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeFlowOutput(
        flowArn: String,
        outputArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveFlowOutputResponse {
        let input = RemoveFlowOutputRequest(
            flowArn: flowArn, 
            outputArn: outputArn
        )
        return try await self.removeFlowOutput(input, logger: logger)
    }

    ///  Removes a source from an existing flow. This request can be made only if there is more than one source on the flow.
    @Sendable
    @inlinable
    public func removeFlowSource(_ input: RemoveFlowSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveFlowSourceResponse {
        try await self.client.execute(
            operation: "RemoveFlowSource", 
            path: "/v1/flows/{FlowArn}/source/{SourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes a source from an existing flow. This request can be made only if there is more than one source on the flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to remove a source from.
    ///   - sourceArn:  The ARN of the source that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeFlowSource(
        flowArn: String,
        sourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveFlowSourceResponse {
        let input = RemoveFlowSourceRequest(
            flowArn: flowArn, 
            sourceArn: sourceArn
        )
        return try await self.removeFlowSource(input, logger: logger)
    }

    ///  Removes a VPC Interface from an existing flow. This request can be made only on a VPC interface that does not have a Source or Output associated with it. If the VPC interface is referenced by a Source or Output, you must first delete or update the Source or Output to no longer reference the VPC interface.
    @Sendable
    @inlinable
    public func removeFlowVpcInterface(_ input: RemoveFlowVpcInterfaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveFlowVpcInterfaceResponse {
        try await self.client.execute(
            operation: "RemoveFlowVpcInterface", 
            path: "/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes a VPC Interface from an existing flow. This request can be made only on a VPC interface that does not have a Source or Output associated with it. If the VPC interface is referenced by a Source or Output, you must first delete or update the Source or Output to no longer reference the VPC interface.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to remove a VPC interface from.
    ///   - vpcInterfaceName:  The name of the VPC interface that you want to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeFlowVpcInterface(
        flowArn: String,
        vpcInterfaceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveFlowVpcInterfaceResponse {
        let input = RemoveFlowVpcInterfaceRequest(
            flowArn: flowArn, 
            vpcInterfaceName: vpcInterfaceName
        )
        return try await self.removeFlowVpcInterface(input, logger: logger)
    }

    ///  Revokes an entitlement from a flow. Once an entitlement is revoked, the content becomes unavailable to the subscriber and the associated output is removed.
    @Sendable
    @inlinable
    public func revokeFlowEntitlement(_ input: RevokeFlowEntitlementRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RevokeFlowEntitlementResponse {
        try await self.client.execute(
            operation: "RevokeFlowEntitlement", 
            path: "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Revokes an entitlement from a flow. Once an entitlement is revoked, the content becomes unavailable to the subscriber and the associated output is removed.
    ///
    /// Parameters:
    ///   - entitlementArn:  The Amazon Resource Name (ARN) of the entitlement that you want to revoke.
    ///   - flowArn:  The flow that you want to revoke an entitlement from.
    ///   - logger: Logger use during operation
    @inlinable
    public func revokeFlowEntitlement(
        entitlementArn: String,
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RevokeFlowEntitlementResponse {
        let input = RevokeFlowEntitlementRequest(
            entitlementArn: entitlementArn, 
            flowArn: flowArn
        )
        return try await self.revokeFlowEntitlement(input, logger: logger)
    }

    ///  Starts a flow.
    @Sendable
    @inlinable
    public func startFlow(_ input: StartFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartFlowResponse {
        try await self.client.execute(
            operation: "StartFlow", 
            path: "/v1/flows/start/{FlowArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Starts a flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to start.
    ///   - logger: Logger use during operation
    @inlinable
    public func startFlow(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartFlowResponse {
        let input = StartFlowRequest(
            flowArn: flowArn
        )
        return try await self.startFlow(input, logger: logger)
    }

    ///  Stops a flow.
    @Sendable
    @inlinable
    public func stopFlow(_ input: StopFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopFlowResponse {
        try await self.client.execute(
            operation: "StopFlow", 
            path: "/v1/flows/stop/{FlowArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Stops a flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopFlow(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopFlowResponse {
        let input = StopFlowRequest(
            flowArn: flowArn
        )
        return try await self.stopFlow(input, logger: logger)
    }

    ///  Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are deleted as well.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are deleted as well.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) that identifies the MediaConnect resource to which to add tags.
    ///   - tags:  A map from tag keys to values. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    ///  Deletes specified tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes specified tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource that you want to untag.
    ///   - tagKeys: The keys of the tags to be removed.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    ///  Updates the bridge.
    @Sendable
    @inlinable
    public func updateBridge(_ input: UpdateBridgeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBridgeResponse {
        try await self.client.execute(
            operation: "UpdateBridge", 
            path: "/v1/bridges/{BridgeArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the bridge.
    ///
    /// Parameters:
    ///   - bridgeArn:  TheAmazon Resource Name (ARN) of the bridge that you want to update.
    ///   - egressGatewayBridge:  A cloud-to-ground bridge. The content comes from an existing MediaConnect flow and is delivered to your premises.
    ///   - ingressGatewayBridge:  A ground-to-cloud bridge. The content originates at your premises and is delivered to the cloud.
    ///   - sourceFailoverConfig:  The settings for source failover.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBridge(
        bridgeArn: String,
        egressGatewayBridge: UpdateEgressGatewayBridgeRequest? = nil,
        ingressGatewayBridge: UpdateIngressGatewayBridgeRequest? = nil,
        sourceFailoverConfig: UpdateFailoverConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBridgeResponse {
        let input = UpdateBridgeRequest(
            bridgeArn: bridgeArn, 
            egressGatewayBridge: egressGatewayBridge, 
            ingressGatewayBridge: ingressGatewayBridge, 
            sourceFailoverConfig: sourceFailoverConfig
        )
        return try await self.updateBridge(input, logger: logger)
    }

    ///  Updates an existing bridge output.
    @Sendable
    @inlinable
    public func updateBridgeOutput(_ input: UpdateBridgeOutputRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBridgeOutputResponse {
        try await self.client.execute(
            operation: "UpdateBridgeOutput", 
            path: "/v1/bridges/{BridgeArn}/outputs/{OutputName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing bridge output.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - networkOutput:  The network of the bridge output.
    ///   - outputName:  Tname of the output that you want to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBridgeOutput(
        bridgeArn: String,
        networkOutput: UpdateBridgeNetworkOutputRequest? = nil,
        outputName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBridgeOutputResponse {
        let input = UpdateBridgeOutputRequest(
            bridgeArn: bridgeArn, 
            networkOutput: networkOutput, 
            outputName: outputName
        )
        return try await self.updateBridgeOutput(input, logger: logger)
    }

    ///  Updates an existing bridge source.
    @Sendable
    @inlinable
    public func updateBridgeSource(_ input: UpdateBridgeSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBridgeSourceResponse {
        try await self.client.execute(
            operation: "UpdateBridgeSource", 
            path: "/v1/bridges/{BridgeArn}/sources/{SourceName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing bridge source.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update.
    ///   - flowSource:  The name of the flow that you want to update.
    ///   - networkSource:  The network for the bridge source.
    ///   - sourceName:  The name of the source that you want to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBridgeSource(
        bridgeArn: String,
        flowSource: UpdateBridgeFlowSourceRequest? = nil,
        networkSource: UpdateBridgeNetworkSourceRequest? = nil,
        sourceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBridgeSourceResponse {
        let input = UpdateBridgeSourceRequest(
            bridgeArn: bridgeArn, 
            flowSource: flowSource, 
            networkSource: networkSource, 
            sourceName: sourceName
        )
        return try await self.updateBridgeSource(input, logger: logger)
    }

    ///  Updates the bridge state.
    @Sendable
    @inlinable
    public func updateBridgeState(_ input: UpdateBridgeStateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBridgeStateResponse {
        try await self.client.execute(
            operation: "UpdateBridgeState", 
            path: "/v1/bridges/{BridgeArn}/state", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the bridge state.
    ///
    /// Parameters:
    ///   - bridgeArn:  The Amazon Resource Name (ARN) of the bridge that you want to update the state of.
    ///   - desiredState:  The desired state for the bridge.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBridgeState(
        bridgeArn: String,
        desiredState: DesiredState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBridgeStateResponse {
        let input = UpdateBridgeStateRequest(
            bridgeArn: bridgeArn, 
            desiredState: desiredState
        )
        return try await self.updateBridgeState(input, logger: logger)
    }

    ///  Updates an existing flow.
    @Sendable
    @inlinable
    public func updateFlow(_ input: UpdateFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowResponse {
        try await self.client.execute(
            operation: "UpdateFlow", 
            path: "/v1/flows/{FlowArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing flow.
    ///
    /// Parameters:
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that you want to update.
    ///   - flowSize:  Determines the processing capacity and feature set of the flow.
    ///   - maintenance:  The maintenance setting of the flow.
    ///   - ndiConfig:  Specifies the configuration settings for NDI outputs. Required when the flow includes NDI outputs.
    ///   - sourceFailoverConfig:  The settings for source failover.
    ///   - sourceMonitoringConfig:  The settings for source monitoring.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFlow(
        flowArn: String,
        flowSize: FlowSize? = nil,
        maintenance: UpdateMaintenance? = nil,
        ndiConfig: NdiConfig? = nil,
        sourceFailoverConfig: UpdateFailoverConfig? = nil,
        sourceMonitoringConfig: MonitoringConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowResponse {
        let input = UpdateFlowRequest(
            flowArn: flowArn, 
            flowSize: flowSize, 
            maintenance: maintenance, 
            ndiConfig: ndiConfig, 
            sourceFailoverConfig: sourceFailoverConfig, 
            sourceMonitoringConfig: sourceMonitoringConfig
        )
        return try await self.updateFlow(input, logger: logger)
    }

    ///  Updates an entitlement. You can change an entitlement's description, subscribers, and encryption. If you change the subscribers, the service will remove the outputs that are are used by the subscribers that are removed.
    @Sendable
    @inlinable
    public func updateFlowEntitlement(_ input: UpdateFlowEntitlementRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowEntitlementResponse {
        try await self.client.execute(
            operation: "UpdateFlowEntitlement", 
            path: "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an entitlement. You can change an entitlement's description, subscribers, and encryption. If you change the subscribers, the service will remove the outputs that are are used by the subscribers that are removed.
    ///
    /// Parameters:
    ///   - description:  A description of the entitlement. This description appears only on the MediaConnect console and will not be seen by the subscriber or end user.
    ///   - encryption:  The type of encryption that will be used on the output associated with this entitlement. Allowable encryption types: static-key, speke.
    ///   - entitlementArn:  The Amazon Resource Name (ARN) of the entitlement that you want to update.
    ///   - entitlementStatus:  An indication of whether you want to enable the entitlement to allow access, or disable it to stop streaming content to the subscriber’s flow temporarily. If you don’t specify the entitlementStatus field in your request, MediaConnect leaves the value unchanged.
    ///   - flowArn:  The ARN of the flow that is associated with the entitlement that you want to update.
    ///   - subscribers:  The Amazon Web Services account IDs that you want to share your content with. The receiving accounts (subscribers) will be allowed to create their own flow using your content as the source.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFlowEntitlement(
        description: String? = nil,
        encryption: UpdateEncryption? = nil,
        entitlementArn: String,
        entitlementStatus: EntitlementStatus? = nil,
        flowArn: String,
        subscribers: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowEntitlementResponse {
        let input = UpdateFlowEntitlementRequest(
            description: description, 
            encryption: encryption, 
            entitlementArn: entitlementArn, 
            entitlementStatus: entitlementStatus, 
            flowArn: flowArn, 
            subscribers: subscribers
        )
        return try await self.updateFlowEntitlement(input, logger: logger)
    }

    ///  Updates an existing media stream.
    @Sendable
    @inlinable
    public func updateFlowMediaStream(_ input: UpdateFlowMediaStreamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowMediaStreamResponse {
        try await self.client.execute(
            operation: "UpdateFlowMediaStream", 
            path: "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing media stream.
    ///
    /// Parameters:
    ///   - attributes:  The attributes that you want to assign to the media stream.
    ///   - clockRate: The sample rate for the stream. This value in measured in kHz.
    ///   - description: A description that can help you quickly identify what your media stream is used for.
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that is associated with the media stream that you updated.
    ///   - mediaStreamName:  The media stream that you updated.
    ///   - mediaStreamType: The type of media stream.
    ///   - videoFormat: The resolution of the video.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFlowMediaStream(
        attributes: MediaStreamAttributesRequest? = nil,
        clockRate: Int? = nil,
        description: String? = nil,
        flowArn: String,
        mediaStreamName: String,
        mediaStreamType: MediaStreamType? = nil,
        videoFormat: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowMediaStreamResponse {
        let input = UpdateFlowMediaStreamRequest(
            attributes: attributes, 
            clockRate: clockRate, 
            description: description, 
            flowArn: flowArn, 
            mediaStreamName: mediaStreamName, 
            mediaStreamType: mediaStreamType, 
            videoFormat: videoFormat
        )
        return try await self.updateFlowMediaStream(input, logger: logger)
    }

    ///  Updates an existing flow output.
    @Sendable
    @inlinable
    public func updateFlowOutput(_ input: UpdateFlowOutputRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowOutputResponse {
        try await self.client.execute(
            operation: "UpdateFlowOutput", 
            path: "/v1/flows/{FlowArn}/outputs/{OutputArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an existing flow output.
    ///
    /// Parameters:
    ///   - cidrAllowList:  The range of IP addresses that should be allowed to initiate output requests to this flow. These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.
    ///   - description:  A description of the output. This description appears only on the MediaConnect console and will not be seen by the end user.
    ///   - destination:  The IP address where you want to send the output.
    ///   - encryption:  The type of key used for the encryption. If no keyType is provided, the service will use the default setting (static-key). Allowable encryption types: static-key.
    ///   - flowArn:  The Amazon Resource Name (ARN) of the flow that is associated with the output that you want to update.
    ///   - maxLatency:  The maximum latency in milliseconds. This parameter applies only to RIST-based and Zixi-based streams.
    ///   - mediaStreamOutputConfigurations:  The media streams that are associated with the output, and the parameters for those associations.
    ///   - minLatency:  The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency.
    ///   - ndiProgramName:  A suffix for the names of the NDI sources that the flow creates. If a custom name isn't specified, MediaConnect uses the output name.
    ///   - ndiSpeedHqQuality: A quality setting for the NDI Speed HQ encoder.
    ///   - outputArn:  The ARN of the output that you want to update.
    ///   - outputStatus:  An indication of whether the output should transmit data or not. If you don't specify the outputStatus field in your request, MediaConnect leaves the value unchanged.
    ///   - port:  The port to use when content is distributed to this output.
    ///   - protocol:  The protocol to use for the output.  Elemental MediaConnect no longer supports the Fujitsu QoS protocol. This reference is maintained for legacy purposes only.
    ///   - remoteId:  The remote ID for the Zixi-pull stream.
    ///   - senderControlPort:  The port that the flow uses to send outbound requests to initiate connection with the sender.
    ///   - senderIpAddress:  The IP address that the flow communicates with to initiate connection with the sender.
    ///   - smoothingLatency:  The smoothing latency in milliseconds for RIST, RTP, and RTP-FEC streams.
    ///   - streamId:  The stream ID that you want to use for this transport. This parameter applies only to Zixi and SRT caller-based streams.
    ///   - vpcInterfaceAttachment:  The name of the VPC interface attachment to use for this output.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFlowOutput(
        cidrAllowList: [String]? = nil,
        description: String? = nil,
        destination: String? = nil,
        encryption: UpdateEncryption? = nil,
        flowArn: String,
        maxLatency: Int? = nil,
        mediaStreamOutputConfigurations: [MediaStreamOutputConfigurationRequest]? = nil,
        minLatency: Int? = nil,
        ndiProgramName: String? = nil,
        ndiSpeedHqQuality: Int? = nil,
        outputArn: String,
        outputStatus: OutputStatus? = nil,
        port: Int? = nil,
        protocol: `Protocol`? = nil,
        remoteId: String? = nil,
        senderControlPort: Int? = nil,
        senderIpAddress: String? = nil,
        smoothingLatency: Int? = nil,
        streamId: String? = nil,
        vpcInterfaceAttachment: VpcInterfaceAttachment? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowOutputResponse {
        let input = UpdateFlowOutputRequest(
            cidrAllowList: cidrAllowList, 
            description: description, 
            destination: destination, 
            encryption: encryption, 
            flowArn: flowArn, 
            maxLatency: maxLatency, 
            mediaStreamOutputConfigurations: mediaStreamOutputConfigurations, 
            minLatency: minLatency, 
            ndiProgramName: ndiProgramName, 
            ndiSpeedHqQuality: ndiSpeedHqQuality, 
            outputArn: outputArn, 
            outputStatus: outputStatus, 
            port: port, 
            protocol: `protocol`, 
            remoteId: remoteId, 
            senderControlPort: senderControlPort, 
            senderIpAddress: senderIpAddress, 
            smoothingLatency: smoothingLatency, 
            streamId: streamId, 
            vpcInterfaceAttachment: vpcInterfaceAttachment
        )
        return try await self.updateFlowOutput(input, logger: logger)
    }

    ///  Updates the source of a flow.
    @Sendable
    @inlinable
    public func updateFlowSource(_ input: UpdateFlowSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowSourceResponse {
        try await self.client.execute(
            operation: "UpdateFlowSource", 
            path: "/v1/flows/{FlowArn}/source/{SourceArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the source of a flow.
    ///
    /// Parameters:
    ///   - decryption: The type of encryption that is used on the content ingested from the source.
    ///   - description: A description of the source. This description is not visible outside of the current Amazon Web Services account.
    ///   - entitlementArn: The Amazon Resource Name (ARN) of the entitlement that allows you to subscribe to the flow. The entitlement is set by the content originator, and the ARN is generated as part of the originator's flow.
    ///   - flowArn:  The ARN of the flow that you want to update.
    ///   - gatewayBridgeSource: The source configuration for cloud flows receiving a stream from a bridge.
    ///   - ingestPort: The port that the flow listens on for incoming content. If the protocol of the source is Zixi, the port must be set to 2088.
    ///   - maxBitrate: The maximum bitrate for RIST, RTP, and RTP-FEC streams.
    ///   - maxLatency: The maximum latency in milliseconds. This parameter applies only to RIST-based and Zixi-based streams.
    ///   - maxSyncBuffer: The size of the buffer (in milliseconds) to use to sync incoming source data.
    ///   - mediaStreamSourceConfigurations: The media stream that is associated with the source, and the parameters for that association.
    ///   - minLatency: The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency.
    ///   - protocol: The protocol that the source uses to deliver the content to MediaConnect.   Elemental MediaConnect no longer supports the Fujitsu QoS protocol. This reference is maintained for legacy purposes only.
    ///   - senderControlPort: The port that the flow uses to send outbound requests to initiate connection with the sender.
    ///   - senderIpAddress: The IP address that the flow communicates with to initiate connection with the sender.
    ///   - sourceArn: The ARN of the source that you want to update.
    ///   - sourceListenerAddress: The source IP or domain name for SRT-caller protocol.
    ///   - sourceListenerPort: Source port for SRT-caller protocol.
    ///   - streamId: The stream ID that you want to use for this transport. This parameter applies only to Zixi and SRT caller-based streams.
    ///   - vpcInterfaceName: The name of the VPC interface that you want to send your output to.
    ///   - whitelistCidr: The range of IP addresses that are allowed to contribute content to your source. Format the IP addresses as a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFlowSource(
        decryption: UpdateEncryption? = nil,
        description: String? = nil,
        entitlementArn: String? = nil,
        flowArn: String,
        gatewayBridgeSource: UpdateGatewayBridgeSourceRequest? = nil,
        ingestPort: Int? = nil,
        maxBitrate: Int? = nil,
        maxLatency: Int? = nil,
        maxSyncBuffer: Int? = nil,
        mediaStreamSourceConfigurations: [MediaStreamSourceConfigurationRequest]? = nil,
        minLatency: Int? = nil,
        protocol: `Protocol`? = nil,
        senderControlPort: Int? = nil,
        senderIpAddress: String? = nil,
        sourceArn: String,
        sourceListenerAddress: String? = nil,
        sourceListenerPort: Int? = nil,
        streamId: String? = nil,
        vpcInterfaceName: String? = nil,
        whitelistCidr: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowSourceResponse {
        let input = UpdateFlowSourceRequest(
            decryption: decryption, 
            description: description, 
            entitlementArn: entitlementArn, 
            flowArn: flowArn, 
            gatewayBridgeSource: gatewayBridgeSource, 
            ingestPort: ingestPort, 
            maxBitrate: maxBitrate, 
            maxLatency: maxLatency, 
            maxSyncBuffer: maxSyncBuffer, 
            mediaStreamSourceConfigurations: mediaStreamSourceConfigurations, 
            minLatency: minLatency, 
            protocol: `protocol`, 
            senderControlPort: senderControlPort, 
            senderIpAddress: senderIpAddress, 
            sourceArn: sourceArn, 
            sourceListenerAddress: sourceListenerAddress, 
            sourceListenerPort: sourceListenerPort, 
            streamId: streamId, 
            vpcInterfaceName: vpcInterfaceName, 
            whitelistCidr: whitelistCidr
        )
        return try await self.updateFlowSource(input, logger: logger)
    }

    /// Updates an existing gateway instance.
    @Sendable
    @inlinable
    public func updateGatewayInstance(_ input: UpdateGatewayInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateGatewayInstanceResponse {
        try await self.client.execute(
            operation: "UpdateGatewayInstance", 
            path: "/v1/gateway-instances/{GatewayInstanceArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing gateway instance.
    ///
    /// Parameters:
    ///   - bridgePlacement: The state of the instance. ACTIVE or INACTIVE.
    ///   - gatewayInstanceArn: The Amazon Resource Name (ARN) of the gateway instance that you want to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGatewayInstance(
        bridgePlacement: BridgePlacement? = nil,
        gatewayInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGatewayInstanceResponse {
        let input = UpdateGatewayInstanceRequest(
            bridgePlacement: bridgePlacement, 
            gatewayInstanceArn: gatewayInstanceArn
        )
        return try await self.updateGatewayInstance(input, logger: logger)
    }
}

extension MediaConnect {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: MediaConnect, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension MediaConnect {
    /// Return PaginatorSequence for operation ``listBridges(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBridgesPaginator(
        _ input: ListBridgesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBridgesRequest, ListBridgesResponse> {
        return .init(
            input: input,
            command: self.listBridges,
            inputKey: \ListBridgesRequest.nextToken,
            outputKey: \ListBridgesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBridges(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterArn:  Filter the list results to display only the bridges associated with the selected ARN.
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListBridges request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBridgesPaginator(
        filterArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBridgesRequest, ListBridgesResponse> {
        let input = ListBridgesRequest(
            filterArn: filterArn, 
            maxResults: maxResults
        )
        return self.listBridgesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEntitlements(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEntitlementsPaginator(
        _ input: ListEntitlementsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEntitlementsRequest, ListEntitlementsResponse> {
        return .init(
            input: input,
            command: self.listEntitlements,
            inputKey: \ListEntitlementsRequest.nextToken,
            outputKey: \ListEntitlementsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEntitlements(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListEntitlements request with set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 20 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEntitlementsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEntitlementsRequest, ListEntitlementsResponse> {
        let input = ListEntitlementsRequest(
            maxResults: maxResults
        )
        return self.listEntitlementsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFlowsPaginator(
        _ input: ListFlowsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFlowsRequest, ListFlowsResponse> {
        return .init(
            input: input,
            command: self.listFlows,
            inputKey: \ListFlowsRequest.nextToken,
            outputKey: \ListFlowsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListFlows request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFlowsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFlowsRequest, ListFlowsResponse> {
        let input = ListFlowsRequest(
            maxResults: maxResults
        )
        return self.listFlowsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGatewayInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewayInstancesPaginator(
        _ input: ListGatewayInstancesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGatewayInstancesRequest, ListGatewayInstancesResponse> {
        return .init(
            input: input,
            command: self.listGatewayInstances,
            inputKey: \ListGatewayInstancesRequest.nextToken,
            outputKey: \ListGatewayInstancesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGatewayInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterArn:  Filter the list results to display only the instances associated with the selected Gateway ARN.
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListInstances request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewayInstancesPaginator(
        filterArn: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGatewayInstancesRequest, ListGatewayInstancesResponse> {
        let input = ListGatewayInstancesRequest(
            filterArn: filterArn, 
            maxResults: maxResults
        )
        return self.listGatewayInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewaysPaginator(
        _ input: ListGatewaysRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListGatewaysRequest, ListGatewaysResponse> {
        return .init(
            input: input,
            command: self.listGateways,
            inputKey: \ListGatewaysRequest.nextToken,
            outputKey: \ListGatewaysResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListGateways request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listGatewaysPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListGatewaysRequest, ListGatewaysResponse> {
        let input = ListGatewaysRequest(
            maxResults: maxResults
        )
        return self.listGatewaysPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingsPaginator(
        _ input: ListOfferingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOfferingsRequest, ListOfferingsResponse> {
        return .init(
            input: input,
            command: self.listOfferings,
            inputKey: \ListOfferingsRequest.nextToken,
            outputKey: \ListOfferingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListOfferings request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOfferingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOfferingsRequest, ListOfferingsResponse> {
        let input = ListOfferingsRequest(
            maxResults: maxResults
        )
        return self.listOfferingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReservations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationsPaginator(
        _ input: ListReservationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReservationsRequest, ListReservationsResponse> {
        return .init(
            input: input,
            command: self.listReservations,
            inputKey: \ListReservationsRequest.nextToken,
            outputKey: \ListReservationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReservations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  The maximum number of results to return per API request.  For example, you submit a ListReservations request with MaxResults set at 5. Although 20 items match your request, the service returns no more than the first 5 items. (The service also returns a NextToken value that you can use to fetch the next batch of results.)  The service might return fewer results than the MaxResults value. If MaxResults is not included in the request, the service defaults to pagination with a maximum of 10 results per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReservationsRequest, ListReservationsResponse> {
        let input = ListReservationsRequest(
            maxResults: maxResults
        )
        return self.listReservationsPaginator(input, logger: logger)
    }
}

extension MediaConnect.ListBridgesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListBridgesRequest {
        return .init(
            filterArn: self.filterArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListEntitlementsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListEntitlementsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListFlowsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListFlowsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListGatewayInstancesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListGatewayInstancesRequest {
        return .init(
            filterArn: self.filterArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListGatewaysRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListGatewaysRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListOfferingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListOfferingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension MediaConnect.ListReservationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> MediaConnect.ListReservationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension MediaConnect {
    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowActive(
        _ input: DescribeFlowRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeFlowRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("flow.status", expected: "ACTIVE")),
                .init(state: .retry, matcher: try! JMESPathMatcher("flow.status", expected: "STARTING")),
                .init(state: .retry, matcher: try! JMESPathMatcher("flow.status", expected: "UPDATING")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("InternalServerErrorException")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("ServiceUnavailableException")),
                .init(state: .failure, matcher: try! JMESPathMatcher("flow.status", expected: "STANDBY")),
                .init(state: .failure, matcher: try! JMESPathMatcher("flow.status", expected: "ERROR")),
            ],
            minDelayTime: .seconds(3),
            command: self.describeFlow
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - flowArn:  The ARN of the flow that you want to describe.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowActive(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeFlowRequest(
            flowArn: flowArn
        )
        try await self.waitUntilFlowActive(input, logger: logger)
    }

    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowDeleted(
        _ input: DescribeFlowRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeFlowRequest, _>(
            acceptors: [
                .init(state: .success, matcher: AWSErrorCodeMatcher("NotFoundException")),
                .init(state: .retry, matcher: try! JMESPathMatcher("flow.status", expected: "DELETING")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("InternalServerErrorException")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("ServiceUnavailableException")),
                .init(state: .failure, matcher: try! JMESPathMatcher("flow.status", expected: "ERROR")),
            ],
            minDelayTime: .seconds(3),
            command: self.describeFlow
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - flowArn:  The ARN of the flow that you want to describe.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowDeleted(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeFlowRequest(
            flowArn: flowArn
        )
        try await self.waitUntilFlowDeleted(input, logger: logger)
    }

    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowStandby(
        _ input: DescribeFlowRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeFlowRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("flow.status", expected: "STANDBY")),
                .init(state: .retry, matcher: try! JMESPathMatcher("flow.status", expected: "STOPPING")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("InternalServerErrorException")),
                .init(state: .retry, matcher: AWSErrorCodeMatcher("ServiceUnavailableException")),
                .init(state: .failure, matcher: try! JMESPathMatcher("flow.status", expected: "ERROR")),
            ],
            minDelayTime: .seconds(3),
            command: self.describeFlow
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeFlow(_:logger:)``.
    ///
    /// - Parameters:
    ///   - flowArn:  The ARN of the flow that you want to describe.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFlowStandby(
        flowArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeFlowRequest(
            flowArn: flowArn
        )
        try await self.waitUntilFlowStandby(input, logger: logger)
    }
}
